\chapter{示例解析}
\label{ch:examples}

本章通过三个示例展示 cpp-orchestrator 的实际效果：基础类转换、委托与泛型、复杂依赖处理。

\section{示例一：基础模型类}

输入 C\# 代码：

\begin{lstlisting}[language=C]
namespace MyGame.Models;

public class Player
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public DateTime? LastLogin { get; set; }
}
\end{lstlisting}

生成的 C++ 头文件：

\begin{lstlisting}[language=C++]
#pragma once
#include <optional>
#include <string>

namespace my_game::models {

class Player {
public:
    Player() = default;

    int get_id() const;
    void set_id(int value);

    const std::string& get_name() const;
    void set_name(std::string value);

    std::optional<std::string> get_last_login() const;
    void set_last_login(std::optional<std::string> value);

private:
    int m_id{0};
    std::string m_name{};
    std::optional<std::string> m_last_login{};
};

} // namespace my_game::models
\end{lstlisting}

要点说明：属性被展开为 getter/setter，命名规范自动转换，\code{DateTime?} 映射为 \code{std::optional<std::string>}（可结合自定义映射调整为 chrono 类型）。

\section{示例二：委托与泛型}

C\# 源码：

\begin{lstlisting}[language=C]
namespace Ktsu.DelegateTransform;

public class DelegateTransform<T>
{
    public T With(T input, Action<T> action)
    {
        action(input);
        return input;
    }

    public T With(T input, Func<T> factory)
    {
        return factory();
    }
}
\end{lstlisting}

生成的 C++ 代码：

\begin{lstlisting}[language=C++]
#pragma once
#include <functional>

namespace ktsu::delegate_transform {

template <typename T>
class DelegateTransform {
public:
    T with(T input, std::function<void(T&)> action)
    {
        action(input);
        return input;
    }

    T with(T input, std::function<T()> factory)
    {
        return factory();
    }
};

} // namespace ktsu::delegate_transform
\end{lstlisting}

委托 \code{Action<T>}、\code{Func<T>} 自动映射为 \code{std::function}，同时模板参数得到完整保留。

\section{示例三：复杂依赖}

在 Roblox API 示例中，原始 C\# 类型引用了多个外部实体。cpp-orchestrator 自动生成桩代码：

\begin{lstlisting}[language=C++]
// common_stubs.hpp 摘录
struct User {
    int32_t id{0};
    std::string username;
};

struct Clan {
    int32_t id{0};
    std::string name;
};

struct SearchResult {
    int32_t id{0};
    std::string title;
    std::string snippet;
};
\end{lstlisting}

同时在头文件中自动包含桩代码：

\begin{lstlisting}[language=C++]
#include "common_stubs.hpp"
#include "group_stubs.hpp"
\end{lstlisting}

借助桩代码机制，复杂依赖即可在后续迭代中逐步落地。

\section{小结}

通过上述示例可以看到：

\begin{itemize}[leftmargin=*]
    \item 常见 C\# 结构可直接转为现代 C++ 模板、容器与函数对象
    \item 命名、类型、注释等细节遵循统一规范
    \item 缺失依赖可由桩代码暂时填补，为后续手工实现打下基础
\end{itemize}

更多真实项目样例可以参考仓库中的 \texttt{conversion-evaluation} 数据集。
